package com.chen.function_demo.chapter2;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;

/**
 * 第二章第一节
 * @author 陈哲<p>
 * ================================<p>
 * Date: 2025/5/11<p>
 * Time: 17:54<p>
 * ================================
 */
public class Section1 {
    /*
        1、函数对象的表现形式：（1）lambda表达式（功能更全面） （2）方法引用（写法更简洁）
        （1）lambda表达式组成部分：参数列表、函数体、以及二者的分隔符-> (int a, int b) -> a + b;
        如果函数体只有一行，可以省略{}和return
        （2）方法引用  1、类::静态方法名 2、类::实例方法名 3、对象::实例方法名
        Math::max  (int a, int b) -> Math.max(a, b)
        Student::getName  (Student student) -> student.getName()
        System.out::println  (Object object) -> System.out.println(str)
        Student::new  () -> new Student() 以无参构造举例
        2、函数对象如何分类
        （1）参数个数和类型相同；（2）返回值类型相同；就可归为一类，归为一类后可以使用函数式接口表示
        3、函数式接口：只有一个抽象方法的接口，称为函数式接口，使用@FunctionalInterface注解进行标识，这个注解作用：检查函数式接口是否只有一个抽象方法
     */
    /**
     * 定义一个学生类
     */
    static class Student{
        // 姓名
        private String name;
        // 年龄
        private int age;

        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    }

    /**
     * 归类练习
     * 1、(int a) -> (a & 1) == 0;
     * 2、(int a, int b) -> a - b;
     * 3、(int a, int b, int c) -> a + b + c;
     * 4、() -> new Student();
     * 5、(Student stu) -> stu.getName();
     * 6、(int a, int b) -> a * b;
     * 7、(Student stu) -> stu.getAge();
     * 8、() -> new ArrayList<Student>();
     * 9、(int a) -> BigInteger.valueOf(a).isProbablePrime(100);
     */
    public static void main(String[] args) {
        // 1、5、7、9 一个入参 一个返回结果
        Lambda<Integer, Boolean> lambda = a -> (a & 1) == 0;
        Lambda<Student, String> lambda5 = Student::getName;
        Lambda<Student, Integer> lambda7 = Student::getAge;
        Lambda<Integer, Boolean> lambda9 = a -> BigInteger.valueOf(1).isProbablePrime(100);
        // 2、6 两个入参 一个返回结果
        Lambda2<Integer, Integer, Integer> lambda2 = (a, b) -> a - b;
        Lambda2<Integer, Integer, Integer> lambda6 = (a, b) -> a * b;
        // 3 三个入参 一个返回结果
        Lambda3<Integer, Integer, Integer, Integer> lambda3  = (a, b, c)-> a + b + c;
        // 4 无参 一个返回结果
        Lambda4<Student> lambda4 = Student::new;
        Lambda4<List<Student>> lambda8 = ArrayList::new;
    }

    @FunctionalInterface
    interface Lambda<K,  V> {
        V calculate(K k);
    }
    @FunctionalInterface
    interface Lambda2<K, V, W> {
        W calculate(K k, V v);
    }
    @FunctionalInterface
    interface Lambda3<K, V, W, X> {
        X calculate(K k, V v, W w);
    }
    @FunctionalInterface
    interface Lambda4<T> {
        T calculate();
    }

}
